<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<script>
    //封装集合类
    function Set(){
    //    属性
        this.items = {}

    //    方法
    //    add方法
        Set.prototype.add = function(value){
        //    1、判断集合中是否已经有该元素
            if(this.has(value)){
                return false
            }

        //    2、将元素添加到集合中
            this.items[value] = value
            return true
        }

    //  has方法
        Set.prototype.has = function(value){
            return this.items .hasOwnProperty(value) //判断是否有重复
        }

    //  remove方法
        Set.prototype.remove = function(value){
        //    1、判断集合中是否有该元素
            if(this.has(value)){
                return false
            }

        //    2、将元素从属性中删除
            delete this.items[value]
            return true
        }

    //    clear方法
        Set.prototype.clear = function(){
            this.items = {}
        }

    //    size方法
        Set.prototype.size = function(){
            return Object.keys(this.items).length
        }

    //    获取集合中所有的值
        Set.prototype.values = function(){
            return Object.keys(this.items)
        }

        //集合间的操作
        //  并集
        Set.prototype.union = function(otherSet){ // otherSet另一个集合
        //    this:集合对象A
        //    otherSet:集合对象B
        //    1、创建新的集合
            var unionSet = new Set()

        //    2、将A集合中所有的额元素添加到新集合中
            var values = this.values()
            for(var i = 0;i < values.length;i++){
                unionSet.add(values[i])
            }

        //    3、取出B集合中的元素，判断是否需要加到新的集合中
            values = otherSet.values()
            for(var i = 0;i < values.length;i++){
                unionSet.add(values[i])
            }

            return unionSet //返回新的集合
        }

    //    交集
        Set.prototype.intersection = function(otherSet){
        //    this：集合A
        //    otherSet：集合B
        //    1、创建新的集合
            var intersectionSet = new Set()

        //    2、遍历A中的元素，判断每一个元素是否存在与B中，若存在则存入新集合
            var values = this.values()
            for(var i = 0;i < value.length;i++){
                var item = values[i]
                if(otherSet.has(item)){ //B中也存在这个元素
                    intersectionSet.add(item) //向新集合添加元素
                }
            }

            return intersectionSet //返回新集合
        }

    //    差集(与交集相反)
        Set.prototype.difference = function(otherSet){
            //    this：集合A
            //    otherSet：集合B
            //    1、创建新的集合
            var differenceSet = new Set()

            //    2、遍历A中的元素，判断每一个元素是否存在与B中，若存在则存入新集合
            var values = this.values()
            for(var i = 0;i < value.length;i++){
                var item = values[i]
                if(!otherSet.has(item)){ //B中也存在这个元素
                    differenceSet.add(item) //向新集合添加元素
                }
            }

            return differenceSet //返回新集合
        }

    //    子集
        Set.prototype.subset = function(otherSet){
        //    this:A集合
        //    otherSet:B集合
        //    思路：遍历集合A中所有的元素，如果发现存在集合A中的元素不包含在集合B中，则A不是B的子集，返回false
        //    如果遍历完了整个A集合，所有的元素都在B中存在，则A是B的子集，返回true
            var values = this.values()
            for(var i = 0;i<values.length;i++){ //遍历A集合
                var item = values[i] //获取每一个元素
                if(!otherSet.has(item)){ //存在不包含在B集合中的元素
                    return false
                }
            }
            return true
        }

    }
</script>
</body>
</html>